package com.zhu.day.learn2023;

import java.time.Duration;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class plouti {
    public static void main(String[] args) {
       /* Solution solution = new Solution();
        int stairs = solution.climbStairs(5);
        System.out.println(stairs);
*/
        SolutionMoves solutionMoves = new SolutionMoves();
        int[] ints = {1, 7, 10};
        System.out.println(solutionMoves.minMoves(ints));
        LocalDateTime dateTime = LocalDateTime.parse("2020-11-24T00:00:00");
        Duration between = Duration.between(dateTime, LocalDateTime.parse("2025-06-01T00:00:00"));
        System.out.println("xx-" + between.toDays());
    }

    /**
     * 两数之和等 N,返回他的 index
     */
    static class SolutionSum {
        public int[] twoSum(int[] nums, int target) {
            int n = nums.length;
            for (int i = 0; i < n; ++i) {
                for (int j = i + 1; j < n; ++j) {
                    if (nums[i] + nums[j] == target) {
                        return new int[]{i, j};
                    }
                }
            }
            return new int[0];
        }
    }

    //爬楼梯问题
    static class Solution {
        public int climbStairs(int n) {
            int p = 0, q = 0, r = 1;
            for (int i = 1; i <= n; ++i) {
                p = q;
                q = r;
                r = p + q;
            }
            return r;
        }

    }

    //最小操作次数使数组元素相等https://leetcode.cn/problems/minimum-moves-to-equal-array-elements/solution/zui-xiao-cao-zuo-ci-shu-shi-shu-zu-yuan-3meg3/
    // 给你一个长度为 n 的整数数组，每次操作将会使 n - 1 个元素增加 1 。返回让数组所有元素相等的最小操作次数。
    static class SolutionMoves {
        public int minMoves(int[] nums) {
            if (nums.length <= 0) return -1;
            int minNum = Arrays.stream(nums).min().getAsInt();
            int res = 0;
            for (int num : nums) {
                res += num - minNum;
            }
            return res;
        }
    }

    //665. 非递减数列
    //给你一个长度为n的整数数组nums，请你判断在 最多 改变1 个元素的情况下，该数组能否变成一个非递减数列。
    //我们是这样定义一个非递减数列的：对于数组中任意的i (0 <= i <= n-2)，总满足 nums[i] <= nums[i + 1]。
    static class SolutionPossibility {
        public boolean checkPossibility(int[] nums) {
            int n = nums.length, cnt = 0;
            for (int i = 0; i < n - 1; i++) {
                int x = nums[i];
                int y = nums[i + 1];
                if (x > y) {
                    cnt++;
                    //超过 1 次就不满足条件
                    if (cnt > 1) {
                        return false;
                    }
                    if (i > 0 && y < nums[i - 1]) {
                        nums[i + 1] = x;
                    }
                }
            }
            return true;
        }
    }

    /**
     * 给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。
     * 在每一天，你可以决定是否购买和/或出售股票。你在任何时候最多只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。
     * 返回 你能获得的 最大 利润
     */

    static class SolutionProfit {
        /**
         * 动态 规划
         */
        public static int maxProfit(int[] prices) {
            int length = prices.length;
            if (length < 2) {
                return 0;
            }
            int noHold = 0;//没持有股票
            int hold = -prices[0];//持有股票
            for (int i = 1; i < length; i++) {
                //递推公式转化的
                noHold = Math.max(noHold, hold + prices[i]);
                hold = Math.max(hold, noHold - prices[i]);
            }
            //最后一天肯定是手里没有股票的时候利润才会最大,所以这里返回的是noHold
            return noHold;
        }
    }

    //链表反转//https://juejin.cn/post/6844904022344744967
    static class LinkReverse {
        public static class Node {
            //链表用于存储值
            private int value;
            //指向下一个节点 理解为Node next更加恰当
            private Node node;

            public int getValue() {
                return value;
            }

            public void setValue(int value) {
                this.value = value;
            }

            public Node getNode() {
                return node;
            }

            public void setNode(Node node) {
                this.node = node;
            }

            public Node(int value) {
                this.value = value;
            }
        }

        public static Node revLinkList(Node node) {
            //指向空，可以想象成位于第一个节点之前
            Node newNode = null;
            //指向第一个节点
            Node curNode = node;
            //循环中，使用第三变量事先保存curNode的后面一个节点
            while (curNode != null) {
                Node tempNode = curNode.node;
                //把curNode反向往前指
                curNode.node = newNode;
                //newNode向后移动
                newNode = curNode;
                //curNode 向后移动
                curNode = tempNode;
            }
            return newNode;
        }


        public static void main(String[] args) {
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < 10; i++) {
                list.add(i);
            }
            Node linkedList = createLinkedList(list);
            printList(linkedList);
            Node node = revLinkList(linkedList);
            printList(node);
        }

        //测试方便的打印函数
        public static void printList(Node node) {
            while (node != null) {
                System.out.print(node.getValue());
                System.out.print(" ");
                node = node.getNode();
            }
            System.out.println();
            System.out.println("-----------------");
        }

        //构建函数
        public static Node createLinkedList(List<Integer> list) {
            if (list.isEmpty()) {
                return null;
            }
            Node headNode = new Node(list.get(0));
            Node tempNode = createLinkedList(list.subList(1, list.size()));
            headNode.setNode(tempNode);
            return headNode;
        }
    }
}
